package com.lft.freshordering.controller;

import com.lft.freshordering.response.R;
import com.lft.freshordering.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import cn.hutool.http.HtmlUtil;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.lft.freshordering.entity.User;
import com.lft.freshordering.response.R;
import com.lft.freshordering.service.IUserService;
import com.lft.freshordering.utils.ThreadLocalUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.swing.text.html.HTML;
import javax.validation.Valid;
import java.util.concurrent.TimeUnit;

import javax.servlet.http.HttpServletResponse;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author tyhxzy
 * @since 2024-12-02
 */
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {


    @Autowired
    private IUserService userService;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @RequestMapping("/login")
    public R login(String usname, String password, HttpServletResponse response) {
        // 调用UserService的login方法尝试登录
        String login = userService.login(usname, password);

        // 根据login方法的返回值判断登录结果
        if (login.equals("2")) {
            // 如果返回"2"，表示用户名不存在
            return R.error(401, "用户名不存在");
        } else if (login.equals("1")) {
            // 如果返回"1"，表示密码错误
            return R.error(401, "密码错误");
        }

        // 登录成功，设置响应头
        response.setHeader("A", login);

        // 返回成功信息，携带登录信息
        return R.success(login);
    }


    /**
     * 获取用户信息
     * 该方法通过RequestHeader获取Authorization字段中的token参数来获取用户信息
     * 主要用于验证用户身份并通过ThreadLocal传递用户对象
     *
     * @param token 用户的令牌，用于身份验证
     * @return 返回包含用户信息的响应对象
     */
    @RequestMapping("/userinfo")
    public R getInfo(@RequestHeader("Authorization") String token) {
        // 从ThreadLocal中获取当前请求关联的用户对象
        Object o = ThreadLocalUtil.get();
        // 将获取到的Object类型对象转换为User类型
        User o1 = (User) o;
        // 返回成功响应，包含用户信息
        return R.success(o1);
    }

    // 修改个人信息
    @RequestMapping("/update")
    public R updateUser(@Valid @RequestBody User user, BindingResult bindingResult) {
        // 检查传入的用户信息是否为空
        if (user == null) {
            return R.error(400, "用户信息不能为空");
        }
        // 检查校验结果
        if (bindingResult.hasErrors()) {
            return R.error(400, bindingResult.getFieldError().getDefaultMessage());
        }
        try {
            // 调用服务层方法更新用户信息
            int updateuser = userService.updateuser(user);
            // 根据更新结果返回相应的响应信息
            if (updateuser == 0) {
                return R.error(400, "更新用户信息失败");
            }
            return R.success("更新用户信息成功");
        } catch (Exception e) {
            // 记录异常信息
            log.error("更新用户信息发生异常", e);
            // 返回服务器内部异常信息
            return R.error(500, "服务器内部异常");
        }
    }


    // 根据用户ID选择用户信息
    @RequestMapping("/selectId/{id}")
    public R selectId(@PathVariable Integer id) {
        // 验证用户ID是否有效
        if (id == null || id <= 0) {
            return R.error(400,"无效的用户 ID");
        }
        try {
            // 构建缓存键
            String cacheKey = "user:" + id;
            // 尝试从缓存中获取用户信息
            User selectuser = (User) redisTemplate.opsForValue().get(cacheKey);
            if (selectuser == null) {
                // 如果缓存中没有，从数据库中查询
                selectuser = userService.selectuser(id);
                if (selectuser != null) {
                    // 将查询结果存入缓存，设置过期时间为1小时
                    redisTemplate.opsForValue().set(cacheKey, selectuser, 1, TimeUnit.HOURS);
                }
            }
            // 返回查询结果
            return R.success(selectuser);
        } catch (Exception e) {
            // 记录异常日志
            log.error("选择具有 ID 的用户时出错: " + id, e);
            // 返回友好的错误信息
            return R.error(500,"无法选择用户");
        }
    }

    // 处理用户登出请求的控制器方法
    @RequestMapping("/Logout")
    public R deregister(HttpServletRequest request) {
        // 使当前会话失效，执行用户登出操作
        request.getSession().invalidate();
        // 返回表示登出成功的结果对象
        return R.success("登出成功");
    }

}

